home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / answers / comp / func-lang-faq < prev    next >
Text File  |  1994-04-14  |  37KB  |  946 lines
  1. Newsgroups: comp.lang.functional,comp.answers,news.answers
  2. Path: bloom-beacon.mit.edu!news.media.mit.edu!uhog.mit.edu!MathWorks.Com!yeshua.marcam.com!zip.eecs.umich.edu!newsxfer.itd.umich.edu!gumby!yale!cs.yale.edu!news
  3. From: jones-mark@CS.YALE.EDU (Mark P. Jones)
  4. Subject: comp.lang.functional Frequently Asked Questions (monthly posting)
  5. Message-ID: <1994Apr14.173241.21267@cs.yale.edu>
  6. Followup-To: comp.lang.functional
  7. Summary: This posting contains a list of
  8.          frequently asked questions (and
  9.          their answers) about functional
  10.          programming languages and their
  11.          implementations.
  12. Sender: news@cs.yale.edu (Usenet News)
  13. Nntp-Posting-Host: chickadee.systemsz.cs.yale.edu
  14. Organization: Yale University, Department of Computer Science, New Haven, CT
  15. Date: Thu, 14 Apr 1994 17:32:41 GMT
  16. Approved: news-answers-request@MIT.Edu
  17. Lines: 926
  18. Xref: bloom-beacon.mit.edu comp.lang.functional:2292 comp.answers:4906 news.answers:18052
  19.  
  20.  
  21. Archive-name: func-lang-faq
  22. Last-modified: April 14, 1994
  23.  
  24. ---------------------------------------------------------------------------
  25.              A Frequently Asked Questions list (FAQ) for
  26.                       comp.lang.functional
  27. ---------------------------------------------------------------------------
  28. A copy of this FAQ is available by anonymous ftp from nebula.cs.yale.edu in
  29. the file pub/comp.lang.functional/FAQ.
  30. ---------------------------------------------------------------------------
  31. New this month:
  32.  - Information about NESL
  33.  - A new section in response to the recent threads on `purity and the FAQ'.
  34.  
  35. ---------------------------------------------------------------------------
  36. TABLE OF CONTENTS:
  37.  
  38. 1) GENERAL QUESTIONS
  39.    1.1) What is a functional language?
  40.    1.2) Where can I find out more about the history and motivation
  41.         for functional programming?
  42.    1.3) Are there any books about functional programming?
  43.    1.4) Where is a good place to look for information about current
  44.         research in functional languages?
  45.    1.5) What other newsgroups might be of interest to readers of
  46.         comp.lang.functional?
  47.    1.6) Is comp.lang.functional archived anywhere?
  48.  
  49. 2) FREQUENT TOPICS OF DISCUSSION:
  50.    2.1) What is a monad?
  51.    2.2) How can I write a parser in a functional language?
  52.    2.3) What does it mean to say that a language is strict/non-strict?
  53.    2.4) What about the performance of functional programs?
  54.    2.5) What is a purely functional language?
  55.    2.6) Other subjects:
  56.  
  57. 3) LANGUAGE IMPLEMENTATIONS:
  58.    ASpecT, Caml Light, Clean, Erlang, FP, Gofer, Haskell, Hope, Id, IFP,
  59.    J, Miranda(TM), ML, NESL, OPAL, Scheme and Sisal.
  60.  
  61. 4) OTHER RESOURCES:
  62.    4.1) Bibliographies:
  63.    4.2) Translators:
  64.    4.3) Online services:
  65.  
  66. 5) CREDITS AND DISCLAIMERS:
  67.  
  68. ---------------------------------------------------------------------------
  69. 1) GENERAL QUESTIONS:
  70.  
  71. Comp.lang.functional is an unmoderated usenet newsgroup for the
  72. discussion of functional programming languages, including their
  73. design, application, theoretical foundation and implementation.
  74.  
  75. ---------
  76. 1.1) What is a functional language?
  77.  
  78. Opinions differ, even within the functional programming community,
  79. on the precise definition of ``functional programming languages''.
  80. Here is a definition that, broadly speaking, represents the kind of
  81. languages that are discussed in this newsgroup:
  82.  
  83.   Functional programming is a style of programming that emphasizes
  84.   the evaluation of expressions, rather than execution of commands.
  85.   The expressions in these language are formed by using functions to
  86.   combine basic values.
  87.  
  88.   A functional language is a language that supports and encourages
  89.   programming in a functional style.
  90.  
  91.   For example, consider the task of calculating the sum of the
  92.   integers from 1 to 10.  In an imperative language, this might be
  93.   expressed using a loop, repeatedly updating the values held in
  94.   counter and accumulator variables:
  95.  
  96.        total = 0;
  97.        for (i=1; i<=10; ++i)
  98.            total += i;
  99.  
  100.   In a functional language, the same program would be expressed
  101.   without any variable updates.  For example, in Haskell or Miranda,
  102.   the required sum can be calculated by evaluating the expression:
  103.  
  104.        sum [1..10].
  105.  
  106.   Here, [1..10] is an expression that represents the list of integers
  107.   from 1 to 10, while sum is a function that can be used to calculate
  108.   the sum of an arbitrary list of values.
  109.  
  110.   The same idea could also be used in strict languages like ML or
  111.   Scheme, but it is more common to find such programs written with
  112.   an explicit loop, often expressed as a form of recursion.
  113.   Nevertheless, there is still no need to update the values of the
  114.   variables involved.
  115.  
  116.   SML:    let fun sum i tot = if i=0 then tot else sum (i-1) (tot+i)
  117.           in sum 10 0
  118.           end
  119.  
  120.   Scheme: (define sum
  121.              (lambda (from total)
  122.                  (if (= 0 from)
  123.                      total
  124.                      (sum (- from 1) (+ total from)))))
  125.           (sum 10 0)
  126.  
  127.   Of course, it is often possible to write programs in an imperative
  128.   language using a functional style, and vice versa.  It is then
  129.   a matter of opinion whether a particular language can be described
  130.   as functional or not.
  131.  
  132.  
  133. ---------
  134. 1.2) Where can I find out more about the history and motivation
  135. for functional programming?
  136.  
  137. Here are a couple of references that should help:
  138.  
  139.   "Conception, Evolution, and Application of Functional Programming
  140.   Languages", Paul Hudak, ACM Computing Surveys, Volume 21, Number 3,
  141.   pp.359--411, 1989.
  142.  
  143.   "Why functional programming matters", John Hughes, The Computer
  144.   Journal, Volume 32, Number 2, April 1989.
  145.  
  146.  
  147. ---------
  148. 1.3) Are there any books about functional programming?
  149.  
  150. Yes, there are quite a few.  For details about programming in a
  151. functional language:
  152.  
  153.   o  "Introduction to functional programming", Richard Bird and
  154.      Philip Wadler, Prentice Hall, 1988.  ISBN 0-13-484189-1.
  155.  
  156.   o  "ML for the working programmer", L.C. Paulson, Cambridge
  157.      University Press, 1991.  ISBN 0-521-39022-2.
  158.  
  159. And for those with an interest in implementation:
  160.  
  161.   o  "The implementation of functional programming languages",
  162.      Simon Peyton Jones, Prentice Hall, 1987.  ISBN 0-13-453333-X.
  163.  
  164.   o  "Compiling with continuations", Andrew Appel, Cambridge
  165.      University Press, 1992.  ISBN 0-521-41695-7.
  166.  
  167. For brevity, I've restricted myself to two books in each of the
  168. above categories, one concerned with non-strict languages, the
  169. other with strict languages.  There are several other good books
  170. in each category.
  171.  
  172. The following article may also be of interest to those looking for
  173. books about functional programming:
  174.  
  175.   o  Simon Thompson, Comparative review of functional programming
  176.      textbooks (Bailey, Bird and Wadler, Holyer, Paulson, Reade,
  177.      Sokoloski, Wikstrom), Computing Reviews, May 1992 (CR number
  178.      9205-0262).
  179.  
  180.  
  181. ---------
  182. 1.4) Where is a good place to look for information about current
  183.      research in functional languages?
  184.  
  185. Here are some good places to start:
  186.  
  187. Journals:
  188.   o  The Journal of Functional Programming, published by CUP.
  189.   o  Lisp and Symbolic Computation, published by Kluwer.
  190.  
  191. Conference proceedings:
  192.   o  Lisp and Functional programming (LFP).
  193.   o  Functional Programming Languages and Computer Architecture (FPCA).
  194.   o  Principles of Programming Languages (POPL).
  195.   o  European Symposium on Programming (ESOP).
  196.  
  197.   (Most of these are published by the ACM press, or in the Springer
  198.   Verlag Lecture Notes in Computer Science Series).
  199.  
  200.  
  201. ---------
  202. 1.5) What other newsgroups might be of interest to readers of
  203. comp.lang.functional?
  204.  
  205. There are several newsgroups dealing with related languages and
  206. ideas, including:
  207.  
  208.     comp.lang.ml    for discussion related to ML
  209.     comp.lang.scheme    for discussion about Scheme
  210.     comp.lang.lisp    for discussion about Lisp
  211.     comp.lang.apl    for discussion about APL, J, etc.
  212.  
  213.  
  214. ---------
  215. 1.6) Is comp.lang.functional archived anywhere?
  216.  
  217. No, as far as I know, there is no public archive of comp.lang.functional
  218. (but, of course, many readers keep copies of old articles for their
  219. personal use).  The possibility of establishing a public archive
  220. has been raised a number of times in the past but have not been
  221. pursued due to an apparent lack of interest, and concerns that
  222. archiving might discourage novices from posting articles.
  223.  
  224.  
  225. ---------------------------------------------------------------------------
  226. 2) FREQUENT TOPICS OF DISCUSSION:
  227.  
  228. 2.1) What is a monad?
  229. ---------------------
  230. The concept of a monad comes from category theory; I'll spare you
  231. the full details since you can find these in standard text books
  232. on the subject.  Much of the recent interest in monads in functional
  233. programming is the result of recent papers that show how monads
  234. can be used to describe all kinds of different programming language
  235. features -- for example, I/O, manipulation of state, continuations
  236. and exceptions -- in purely functional languages like Haskell.
  237.  
  238.   o  Philip Wadler, Comprehending Monads (from the ACM conference
  239.      on LISP & Functional Programming, Nice, France, 1990).
  240.  
  241.   o  Philip Wadler, The Essence of Functional Programming (from ACM
  242.      Principles of Programming Languages 1992).
  243.  
  244.   o  Simon Peyton Jones and Philip Wadler, Imperative Functional
  245.      Programming (from ACM Principles of Programming Languages 1993).
  246.  
  247. These papers are essential reading for anyone interested in the
  248. use of monads for functional programming.  Copies of these papers
  249. are currently available by anonymous ftp from ftp.dcs.glasgow.ac.uk
  250. in the subdirectory pub/glasgow-fp/papers.
  251.  
  252.  
  253. 2.2) How can I write a parser in a functional language?
  254. -------------------------------------------------------
  255. A parser is a program that converts a list of input tokens, usually
  256. characters, into a value of the appropriate type.  A simple example
  257. might be a function to find the integer value represented by a
  258. string of digits.  A more complex example might be to translate
  259. programs written in a particular concrete syntax into a suitable
  260. abstract syntax as the first stage in the implementation of a
  261. compiler or interpreter.  There are two common ways to write a
  262. parser in a functional language:
  263.  
  264.   o  Using a parser generator tool.  Some functional language
  265.      implementations support tools that generate a parser automatically
  266.      from a specification of the grammar (in much the same way that
  267.      a C programmer uses yacc).  Different tools are available,
  268.      depending on the language and implementation used.
  269.  
  270.   o  Using combinator parsing.  Parsers are represented by functions
  271.      and combined with a small set of combinators, leading to
  272.      parsers that closely resemble the grammar of the language
  273.      being read.  Parsers written in this way can use backtracking.
  274.      The techniques of combinator parsing have been known for quite
  275.      some time.  Two comparatively recent papers on the subject are:
  276.  
  277.        -  "How to Replace Failure with a List of Successes",
  278.           Philip Wadler, FPCA '85, Springer Verlag LNCS 201, 1985.
  279.  
  280.        -  "Higher-order functions for parsing", Graham Hutton,
  281.       Journal of Functional Programming, 2, 3, July 1992.
  282.  
  283.      The latter paper is also available by anonymous ftp from
  284.      ftp.cs.chalmers.se in the file pub/cs-reports/papers/parsing.dvi
  285.      and includes some references to other related papers.
  286.  
  287.  
  288. 2.3) What does it mean to say that a language is strict/non-strict?
  289. --------------------------------------------------------------------
  290. Here's one (operational) way to explain the difference:
  291.  
  292. In a strict language, the arguments to a function are always
  293. evaluated before it is invoked.  As a result, if the evaluation of
  294. an expression exp does not terminate properly (for example, because
  295. it generates a run-time error or enters an infinite loop), then
  296. neither will an expression of the form  f(exp).  ML and Scheme are
  297. both examples of this.
  298.  
  299. In a non-strict language, the arguments to a function are not
  300. evaluated until their values are actually required.  For example,
  301. evaluating an expression of the form f(exp) may still terminate
  302. properly, even if evaluation of exp would not, if the value of
  303. the parameter is not used in the body of f.  Miranda and Haskell
  304. are examples of this approach.
  305.  
  306. It is possible to support a mixture of these two approaches; some
  307. versions of Hope do this.
  308.  
  309.  
  310. 2.4) What about the performance of functional programs?
  311. -------------------------------------------------------
  312. In some circles, programs written in functional languages, have
  313. obtained a reputation for lack of performance.  Part of this results
  314. from the high-level of abstraction that is common in such programs
  315. and from powerful features like higher-order functions, automatic
  316. storage management, etc.  Of course, the performance of functional
  317. languages keeps improving with new developments in compiler
  318. technology.
  319.  
  320. The paper below compares five current implementations of lazy
  321. functional languages:
  322.  
  323.   ``Benchmarking implementations of lazy functional languages''
  324.   P. H. Hartel and K. G. Langendoen FPCA 93, ACM, pp 341-349
  325.   (By ftp: ftp.fwi.uva.nl, directory pub/functional).
  326.  
  327. Experiments with a heavily optimising compiler for Sisal, a strict
  328. functional language, show that functional programs can be faster
  329. than Fortran:
  330.  
  331.   ``Retire FORTRAN? A debate rekindled''
  332.   D. C. Cann, CACM, 35(8), pp. 81-89, Aug. 1992
  333.  
  334.  
  335. 2.5) What is a purely functional language?
  336. ------------------------------------------
  337. This question has been the subject of some debate in recent messages
  338. posted to comp.lang.functional.  It is widely agreed that languages
  339. like Haskell and Miranda are `purely functional', while SML and
  340. Scheme are not.  However, there are some small differences of
  341. opinion about the precise technical motivation for this distinction.
  342. One definition that has been suggested is as follows:
  343.  
  344.   The term `purely functional language' is often used to describe
  345.   languages which perform all their computations via function
  346.   application.  This is in contrast to languages, like Scheme and
  347.   Standard ML, which are predominantly functional but also allow
  348.   `side effects' (computational effects caused by expression
  349.   evaluation which persist after the evaluation is completed).
  350.  
  351.   Sometimes, the term `purely functional' is also used in a broader
  352.   sense to mean languages which might incorporate computational
  353.   effects, but without altering the notion of `function' (as
  354.   evidenced by the fact that the essential properties of functions
  355.   are preserved.)  Typically, the evaluation of an expression can
  356.   yield a `task' which is then executed separately to cause
  357.   computational effects.  The evaluation and execution phases are
  358.   separated in such a way that the evaluation phase does not
  359.   compromise the standard properties of expressions and functions.
  360.   The input/output mechanisms of Haskell, for example, are of this
  361.   kind.
  362.  
  363.  
  364. 2.6) Other subjects:
  365. --------------------
  366. There probably ought to be something here about programming with
  367. GUIs (Fudgets, eXene, etc.), Input/Output, General Foundations
  368. (basics of lambda calculus, perhaps?), and parallelism.  Anybody
  369. want to write some brief comments addressing one/some of these?
  370. (Some sections are already in preparation.)
  371.  
  372.  
  373. ---------------------------------------------------------------------------
  374. 3) LANGUAGE IMPLEMENTATIONS:
  375.  
  376. ASpecT:        ASpecT is a strict functional language, developed at
  377.         the University of Bremen, originally intended as
  378.         an attempt to provide an implementation for (a
  379.         subset of) Algebraic Specifications of Abstract
  380.         Datatypes.  The system was designed to be as
  381.         user-friendly as possible, including overloading
  382.         facilities and a source-level debugger.  Efficiency
  383.         called for call-by-value evaluation and reference
  384.         counting memory management.
  385.  
  386.         Over the years more and more features were added,
  387.         including subsorting, functionals and restricted
  388.         polymorphism. The ASpecT compiler translates the
  389.         functional source code to C, resulting in fast and
  390.         efficient binaries.
  391.  
  392.         The most important application of ASpecT to date
  393.         is the interactive graph visualization system
  394.         daVinci; currently (Oct '93), version 1.2 is composed
  395.         of 23.000 lines of code. For more information please
  396.         contact the project daVinci by e-mail:
  397.         daVinci@Informatik.Uni-Bremen.DE
  398.  
  399.         ASpecT is available by anonymous FTP from
  400.         wowbagger.PC-Labor.Uni-Bremen.DE in the directory
  401.         /pub/lang/ASpecT. ASpecT has been ported to many
  402. ,
  403.         NeXT, Apple A/UX, PC (OS/2, Linux), Amiga and Atari
  404.         ST/TT.
  405.  
  406.  
  407. Caml Light:     Caml Light is an implementation of the ML language
  408.         that does not comply to the Standard, but is
  409.         distinguished by its small size, modest memory
  410.         requirements, availability on microcomputers, simple
  411.         separate compilation, interface with C, and portable
  412.         graphics functions.
  413.  
  414.         Caml Light 0.6 runs on most Unix machines, on the
  415.         Macintosh and on PCs under MSDOS.
  416.  
  417.         ftp: ftp.inria.fr, directory lang/caml-light
  418.  
  419.  
  420. Clean:          The Concurrent Clean system is a programming
  421.         environment for the functional language Concurrent
  422.         Clean, developed at the University of Nijmegen,
  423.         The Netherlands. The system is one of the fastest
  424.         implementations of functional languages available
  425.         at the moment. Its I/O libraries make it possible
  426.         to do modern, yet purely functional I/O (including
  427.         windows, menus, dialogs etc.) in Concurrent Clean.
  428.         With the Concurrent Clean system it is possible to
  429.         develop real-life applications in a purely functional
  430.         language.  Particular features include:
  431.  
  432.           o lazy and purely functional
  433.           o strongly typed - based on Milner/Mycroft scheme
  434.           o module structure
  435.           o modern I/O
  436.           o programmer-influenced evaluation order by
  437.                     annotations
  438.  
  439.         ftp: host ftp.cs.kun.nl,  directory pub/Clean
  440.         available for: Mac, Sun 3, Sun 4
  441.  
  442.         There is a book describing Concurrent Clean and
  443.         its implementation on sequential and parallel
  444.         architectures:
  445.  
  446.         "Functional Programming and Parallel Graph Rewriting",
  447.         Rinus Plasmeijer and Marko van Eekelen,
  448.         Addison Wesley, International Computer Science Series.
  449.         Hardcover, 571 pages.
  450.         ISBN 0-201-41663-8
  451.  
  452.  
  453. Erlang:        Concurrent functional programming language for
  454.         large industrial real-time systems. Untyped.
  455.         Pattern matching syntax.  Recursion equations.
  456.         Explicit concurrency, asynchronous message
  457.         passing.  Relatively free from side effects.
  458.         Transparent cross-platform distribution.  Primitives
  459.         for detecting run-time errors.  Real-time GC.
  460.         Modules.  Dynamic code replacement (change code
  461.         in running real-time system, without stopping
  462.         system).  Foreign language interface.
  463.  
  464.         Availability: Free version (subject to non-commercial
  465.         license) with no support.  Commercial versions
  466.         with support are available (Erlang Systems AB).
  467.  
  468.         Info: erlang@erix.ericsson.se
  469.         FTP Info: euagate.eua.ericsson.se:/pub/eua/erlang/info
  470.  
  471.         See also:
  472.         "Concurrent Programming in Erlang", J. Armstrong,
  473.         M. Williams & R. Virding, Prentice Hall, 1993.
  474.         ISBN 13-285792-8.
  475.  
  476.  
  477. FP:             Backus' side-effect free, combinator style language
  478.         described by:
  479.  
  480.         "Can Programming be Liberated from the Von
  481.         Neumann Style?", J. Backus, Communications of the
  482.         ACM, 21, 8, pp.613-641, 1978.
  483.  
  484.         There are (at least) three easily accessible
  485.         implementations of FP.  Two of these are available
  486.         from any site that archives comp.sources.unix.
  487.         For example, at gatekeeper.dec.com you will find
  488.         these in:
  489.  
  490.          pub/usenet/comp.sources.unix/volume13/funcproglang
  491.          pub/usenet/comp.sources.unix/volume20/fpc
  492.  
  493.         The first of these is an interpreter, the second a
  494.         translator from FP to C.
  495.  
  496.         The third implementation, IFP is described separately
  497.         below.
  498.  
  499.  
  500. Gofer:        The Gofer system provides an interpreter for a small
  501.         language based closely on the current version of
  502.         the Haskell report.  In particular, Gofer supports
  503.         lazy evaluation, higher-order functions, polymorphic
  504.         typing, pattern-matching, support for overloading, etc.
  505.  
  506.         ftp: nebula.cs.yale.edu,  directory: pub/haskell/gofer
  507.  
  508.         Gofer runs on a wide range of machines including
  509.         PCs, Ataris, Amigas, etc.  as well as larger
  510.         Unix-based systems.  A version for the Apple
  511.         Macintosh has been produced and is available by
  512.         anonymous ftp from ftp.dcs.glasgow.ac.uk in a
  513.         subdirectory of pub/haskell/gofer.
  514.  
  515.         Please note the spelling, derived from the notion
  516.         that functional languages are GOod For Equational
  517.         Reasoning.  This is not to be confused with `Gopher',
  518.         the widely used Internet distributed information
  519.         delivery system!
  520.  
  521.  
  522. Haskell:    In the mid-1980s, there was no "standard" non-strict,
  523.         purely-functional programming language.  A
  524.         language-design committee was set up in 1987, and
  525.         the Haskell language is the result.
  526.  
  527.         The Haskell committee released its report on 1
  528.         April 1990. A revised "Version 1.2" appeared in
  529.         SIGPLAN Notices 27(5) (May 1992), along with a
  530.         tutorial on Haskell by Hudak and Fasel.
  531.  
  532.         At the time of writing, there are three different
  533.         Haskell systems available, developed by groups at
  534.         Chalmers, Glasgow and Yale (several others are
  535.         being developed).  These systems are available
  536.         from the following sites:
  537.            Chalmers    ftp.cs.chalmers.se
  538.            Glasgow    ftp.dcs.glasgow.ac.uk
  539.            Yale        nebula.cs.yale.edu
  540.         At each site, all of the files related to Haskell
  541.         are stored in the directory pub/haskell.  Specialized
  542.         material, or recent releases of these systems may
  543.         sometimes only be available from the systems ``home
  544.         site''.  Machine-readable versions of the Haskell
  545.         report, tutorials, and some programs are also
  546.         available at these sites.
  547.  
  548.         A description of the current status of the various
  549.         Haskell implementations is occasionally posted on
  550.         the Haskell mailing list, and sometimes on
  551.         comp.lang.functional.  Copies of this document are
  552.         often kept on the Haskell sites mentioned above.
  553.         For example, this information may be found in
  554.         pub/haskell/papers/Haskell.status at the Yale site
  555.         (nebula.cs.yale.edu).
  556.  
  557.  
  558. Hope:        A small polymorphically-typed functional language.
  559.         First language to use call-by-pattern.    Hope was
  560.         originally strict, but there are versions with lazy
  561.         lists, or with lazy constructors but strict functions.
  562.         A fully lazy interpreter is available from:
  563.  
  564.         ftp: santos.doc.ic.ac.uk:/pub/papers/R.Paterson/hope.tar.Z
  565.  
  566.  
  567. Id:             The core of Id is a non-strict functional language
  568.         with implicit parallelism.  It has the usual features
  569.         of many modern functional languages, including a
  570.         Hindley/Milner type inference system, algebraic
  571.         types and definitions with clauses and pattern
  572.         matching, and list comprehensions.
  573.  
  574.  
  575. IFP:            The Illinois FP system is a modified version of
  576.         Backus' FP with a more Algol-like syntax and
  577.         structure.  Described in:
  578.  
  579.         "The Illinois Functional Programming Interpreter",
  580.         Arch D. Robison, Proceedings of the SIGPLAN '87
  581.         Symposium on Interpreters and Interpretive Techniques,
  582.         SIGPLAN notices vol 22, no 7, July 1987.
  583.  
  584.         ftp: a.cs.uiuc.edu.    versions for Unix and MSDOS
  585.  
  586.  
  587. J:              J was designed and developed by Ken Iverson and
  588.         Roger Hui.  It is similar to the language APL,
  589.         departing from APL in using using the ASCII alphabet
  590.         exclusively, but employing a spelling scheme that
  591.         retains the advantages of the special alphabet
  592.         required by APL. It has added features and control
  593.         structures that extend its power beyond standard
  594.         APL.  Although it can be used as a conventional
  595.         procedural programming language, it can also be
  596.         used as a pure functional programming language.
  597.  
  598.         ftp: watserv1.waterloo.edu.
  599.  
  600.  
  601. Miranda(TM):    Miranda was designed in 1985-6 by David Turner with
  602.         the aim of providing a standard non-strict purely
  603.         functional language.  It is described in D. A.
  604.         Turner ``Miranda: A Non-Strict Functional Language
  605.         with Polymorphic Types'', Proceedings FPLCA, Nancy,
  606.         France, September 1985 (Springer LNCS vol 201, pp
  607.         1-16) and D. A. Turner ``An Overview of  Miranda'',
  608.         SIGPLAN Notices, vol 21, no 12, pp 158-166 (December
  609.         1986).
  610.  
  611.         Miranda was the first widely disseminated language
  612.         with non-strict semantics and polymorphic strong
  613.         typing, and is now running at over 600 sites,
  614.         including 250 universities.  It is widely used for
  615.         teaching, often in conjunction with "Introduction
  616.         to Functional Programming", by Bird & Wadler, which
  617.         uses a notation closely based on Miranda.
  618.  
  619.         It has also had a strong influence on the subsequent
  620.         development of the field and provided one of the
  621.         main inputs for the design of the later language
  622.         Haskell (see separate entry).
  623.  
  624.         Miranda was awarded a medal for technical achievement
  625.  Computer Society (BCS Awards, 1990).
  626.  
  627.         The Miranda system is a commercial product of
  628.         Research Software Limited.  Miranda release two
  629.         (the current version) supports unbounded precision
  630.         integers and has a module system with provision
  631.         for parameterized modules and a built in "make"
  632.         facility.  The compiler works in conjunction with
  633.         a screen editor and programs are automatically
  634.         recompiled after edits.  There is an online reference
  635.         manual.
  636.  
  637.         Note that the word "Miranda" is a trademark (TM)
  638.         of Research Software Limited.  There are no public
  639.         domain versions of Miranda.
  640.  
  641.         Further information about Miranda may be obtained
  642.         from
  643.                    mira-request@ukc.ac.uk
  644.                 or
  645.                    Research Software Ltd
  646.                    23 St Augustines Road
  647.                    Canterbury CT1 1XP       phone: (+44) 227 471844
  648.                    ENGLAND                  fax:   (+44) 227 454458
  649.  
  650.  
  651. ML:             ML (which stands for Meta-Language) is a family of
  652.         advanced programming languages with [usually]
  653.         functional control structures, strict semantics,
  654.         a strict polymorphic type system, and parameterized
  655.         modules.  It includes Standard ML, Lazy ML, CAML,
  656.         CAML Light, and various research languages.
  657.         Implementations are available on many platforms,
  658.         including PCs, mainframes, most models of workstation,
  659.         multi-processors and supercomputers.  ML has many
  660.         thousands of users, is taught at many universities
  661.         (and is the first programming language taught at
  662.         some).
  663.  
  664.         There is a moderated usenet newsgroup, comp.lang.ml,
  665.         for the discussion of topics related to ML.  A list
  666.         of frequently asked questions for ML is posted to
  667.         this group each month by the moderator, Greg
  668.         Morrisett.  The first paragraph above is taken
  669.         directly from this FAQ.
  670.  
  671.         There are several implementations of ML including
  672.         Poly/ML, SML/NJ, PoplogML, Edinburgh, ANU ML, Micro
  673.         ML, sml2c, Caml Light, and the ML kit.  Further
  674.         details for each of these systems are included in
  675.         the comp.lang.ml FAQ.
  676.  
  677.         The Standard ML language is formally defined by:
  678.  
  679.         "The Definition of Standard ML", Robin Milner, Mads
  680.         Tofte and Robert Harper, MIT, 1990.  ISBN:
  681.         0-262-63132-6
  682.  
  683.         "Commentary on Standard ML", Robin Milner and Mads
  684.         Tofte, MIT, 1991 ISBN: 0-262-63137-7
  685.  
  686.         There are a number of texts describing programming
  687.         in ML.  Again, full details are given in the
  688.         comp.lang.ml FAQ.
  689.  
  690.  
  691. NESL:        NESL is a fine-grained, functional, nested
  692.         data-parallel language.  The current implementation
  693.         runs on workstations, the Connection Machines CM2
  694.         and CM5, the Cray Y-MP and the MasPar MP2.
  695.  
  696.         NESL is loosely based on ML.  It includes a built-in
  697.         parallel data-type, sequences, and parallel operations
  698.         on sequences (the element type of a sequence can
  699.         be any type, not just scalars).  It is based on
  700.         eager evaluation, and supports polymorphism, type
  701.         inference and a limited use of higher-order functions.
  702.         Currently it does not have support for modules and
  703.         its datatype definition is limited.  Except for
  704.         I/O and some system utilities it is purely functional
  705.         (it does not support reference cells or call/cc).
  706.         The compiler is based on delayed compilation and
  707.         compiles separate code for each type a function is
  708.         used with (compiled code is monomorphic).  The
  709.         implementation therefore requires no type bits,
  710.         and can do some important data-layout optimizations
  711.         (e.g. double-precision floats don't need to be
  712.         boxed, and nested sequences can be laid out
  713.         efficiently across multiple processors).  For
  714.         several small benchmark applications on irregular
  715.         and/or dynamic data (e.g graphs and sparse matrices)
  716.         it generates code comparable in efficiency to
  717.         machine-specific low-level code (e.g. Fortran or C).
  718.  
  719.         The system is available via anonymous FTP to
  720.         nesl.scandal.cs.cmu.edu (currently 128.2.222.128),
  721.         in the file code/nesl/nesl.tar.Z (1.2Mbytes).
  722.         There is a README file in the nesl directory that
  723.         contains further information.  You can be added to
  724.         the NESL mailing list by sending e-mail to
  725.         nesl-request@cs.cmu.edu.  The examples and
  726.         documentation are also available separately.
  727.  
  728.  
  729. OPAL:        The language OPAL has been designed as a testbed
  730.         for the development of functional programs. Opal
  731.         molds concepts from Algebraic Specification and
  732.         Functional Programming, which shall favor the
  733.         (formal) development of (large) production-quality
  734.         software that is written in a purely functional
  735.         style.
  736.  
  737.         The core of OPAL is a strongly typed, higher-order,
  738.         strict applicative language which belongs to the
  739.         tradition of HOPE and ML. The algebraic flavour of
  740.         OPAL shows up in the syntactical appearance and
  741.         the preference of parameterization to polymorphism.
  742.  
  743.         OPAL is used for research on the highly optimizing
  744.         compilation of applicative languages. This has
  745.         resulted in a compiler which produces very efficient
  746.         code. The OPAL compiler itself is entirely written
  747.         in OPAL.
  748.  
  749.         Papers describing OPAL, and the OPAL compilation
  750.         system itself, are available by anonymous ftp from:
  751.  
  752.             ftp.cs.tu-berlin.de
  753.  
  754.         This includes an overview of OPAL in the file:
  755.  
  756.             pub/local/uebb/papers/DesignImplOpal.ps.gz
  757.  
  758.         A language tutorial:
  759.  
  760.             pub/local/uebb/papers/TutorialOpal.ps.gz
  761.  
  762.         The compilation system is in the pub/local/uebb/ocs
  763.         directory.  Installation is straightforward and
  764.         has been successfully performed for SPARCs,
  765.         DECstations, NeXTs, and PCs running LINUX.
  766.  
  767.  
  768. Scheme:        Scheme is a dialect of Lisp that stresses conceptual
  769.         elegance and simplicity. It is specified in R4RS
  770.         and IEEE standard P1178. (See question [1-7] for
  771.         details on standards for Scheme.) Scheme is much
  772.         smaller than Common Lisp; the specification is
  773.         about 50 pages.
  774.  
  775.         Scheme is often used in computer science curricula
  776.         and programming language research, due to its
  777.         ability to represent many programming abstractions
  778.         with its simple primitives.
  779.  
  780.         There is an unmoderated usenet newsgroup,
  781.         comp.lang.scheme for the discussion of topics
  782.         related to Scheme, and a list of frequently asked
  783.         questions for Scheme is posted to the group each
  784.         month by Mark Kantrowitz.  The FAQ list is also
  785.         available online from several sources; for example,
  786.         it can be obtained by anonymous ftp from ftp.think.com
  787.         in the file /public/think/lisp/scheme-faq.text.
  788.  
  789.         There are many books and papers dealing with Scheme.
  790.         Please consult the comp.lang.scheme frequently
  791.         asked questions list for further details.
  792.  
  793.         The Scheme Repository, maintained by Ozan S. Yigit,
  794.         is accessible by anonymous ftp at nexus.yorku.ca
  795.         [130.63.9.66] in the directory pub/scheme/, and
  796.         contains a Scheme bibliography, copies of the R4RS
  797.         report, IEEE P1178 specification and other papers,
  798.         sample Scheme code for a variety of purposes,
  799.         several utilities, and some implementations.  The
  800.         repository is mirrored in INRIA, courtesy of
  801.         Christian Queinnec [Ecole Polytechnique and
  802.         INRIA-Rocquencourt], ftp.inria.fr:lang/Scheme.
  803.  
  804.  
  805. Sisal:          Sisal (Streams and Iteration in a Single Assignment
  806.         Language) is a functional language designed with
  807.         several goals in mind:  to support clear, efficient
  808.         expression of scientific programs; to free application
  809.         programmers from details irrelevant to their
  810.         endeavors; and, to allow automatic detection and
  811.         exploitation of the parallelism expressed in source
  812.         programs.
  813.  
  814.         Sisal syntax is modern and easy to read; Sisal code
  815.         looks similar to Pascal, Modula, or Ada, with modern
  816.         constructs and long identifiers. The major difference
  817.         between Sisal and more conventional languages is
  818.         that it does not express explicit program control flow.
  819.  
  820.         Sisal semantics are mathematically sound. Programs
  821.         consist of function definitions and invocations.
  822.         Functions have no side effects, taking as inputs
  823.         only explicitly passed arguments, and producing
  824.         only explicitly returned results. There is no
  825.         concept of state in Sisal.  Identifiers are used,
  826.         rather than variables, to denote values, rather
  827.         than memory locations.
  828.  
  829.         The Sisal language currently exists for several
  830.         shared memory and vector systems that run Berkeley
  831. mmetry,
  832.         the Alliant, the Cray X/MP and Y/MP, Cray 2, and
  833.         a few other less well-known ones.  Sisal is available
  834.         on sequential machines such as Sparc, RS/6000, and
  835.         HP.  Sisal also runs under MS-DOS and Macintosh
  836.         Unix (A/UX). It's been shown to be fairly easy to
  837.         port the entire language system to new machines.
  838.  
  839.         ftp: sisal.llnl.gov (128.115.19.65)
  840.  
  841.         For more information, pleases send an email request to:
  842.             sisal-info-request@sisal.llnl.gov
  843.  
  844.         See also: "Retire FORTRAN? A debate rekindled",
  845.         David Cann, CACM, 35(8), pp.81-89, Aug 1992
  846.  
  847.  
  848. ---------------------------------------------------------------------------
  849. 4) OTHER RESOURCES:
  850.  
  851. 4.1) Bibliographies:
  852.  
  853.   o  Mike Joy maintains a bibliography on Functional Languages,
  854.      in refer(1) format.  It is available by anonymous ftp from:
  855.      ftp.dcs.warwick.ac.uk in the files:
  856.  
  857.        pub/biblio/functional.README pub/biblio/functional.refer.Z
  858.  
  859.   o  Tony Davie maintains a bibliography of over 2,600 papers,
  860.      articles and books on functional programming and functional
  861.      systems.  It can be obtained by anonymous ftp from
  862.      tamdhu.dcs.st-and.ac.uk in the directory pub/staple, either
  863.      as a hypercard stack in pubs.sit.Hqx, or as a (compressed)
  864.      text file in pubs.txt.Z.
  865.  
  866.   o  Wolfgang Schreiner has compiled an annotated bibliography
  867.      on parallel functional programming that lists more than 350
  868.      publications mostly including their *full abstracts*.
  869.  
  870.      You can retrieve the bibliography by anonymous ftp from
  871.      ftp.risc.uni-linz.ac.at (193.170.36.100) in
  872.      pub/reports/parlab/pfpbib2.dvi.Z (or pfpbib2.ps.Z).
  873.  
  874.   o  State in Functional Programming: An Annotated Bibliography,
  875.      edited by P. Hudak and D. Rabin, is available by anonymous
  876.      ftp from nebula.cs.yale.edu in the files:
  877.  
  878.        pub/yale-fp/papers/state-bib.<format>.<compression> where
  879.        <format>      ::= ps | dvi
  880.          <compression> :: = z | Z
  881.  
  882.  
  883. 4.2) Translators:
  884.  
  885.   o  Miranda(TM) to LML and Miranda(TM) to Haskell translators
  886.      written by Denis Howe are available by anonymous ftp from
  887.      wombat.doc.ic.ac.uk (146.169.22.42) in directory pub, files
  888.      mira2hs-1.05 and mira2lml-0.00
  889.  
  890.  
  891. 4.3) Online services:
  892.  
  893.   o If you have wais, the source is listed below, or it can be
  894.     easily obtained from the directory-of-servers. If you don't
  895.     have wais, subscribe to comp.infosystems.wais and find someone
  896.     to ask.
  897.  
  898.     (:source
  899.        :version  3 :ip-address "137.219.17.4" :ip-name
  900.        "coral.cs.jcu.edu.au" :tcp-port 8000 :database-name
  901.        "Func-Prog-Abstracts" :cost 0.00 :cost-unit :free :maintainer
  902.        "farrell@coral.cs.jcu.edu.au" :description "Server created
  903.        with WAIS release 8 b3.1
  904.      on Apr 22 19:06:25 1992 by farrell@coral.cs.jcu.edu.au
  905.  
  906.      Keywords: help intro introduction info information computer
  907.     science technical reports functional programming
  908.  
  909.      This is a small collection of computer science technical
  910.      reports, abstracts and papers gathered from ftp sites etc.
  911.      all over the world. Due to space considerations, I am limiting
  912.      it to functional programming, my area of interest, and papers
  913.      produced by the department (which may or may not be related
  914.      to functional programming).
  915.  
  916.      Comments, problems etc to the maintainer above.  " )
  917.  
  918.  
  919.   o The Free On-Line Dictionary of Computing is available by Gopher
  920.     and FTP from wombat.doc.ic.ac.uk.  It is not restricted to
  921.     functional programming but does include quite a few FP terms.
  922.  
  923.  
  924. ---------------------------------------------------------------------------
  925. 5) CREDITS AND DISCLAIMERS:
  926.  
  927. The information in this article has been taken from public sources,
  928. mostly from articles posted on comp.lang.functional during the past
  929. eighteen months.  This FAQ includes contributions from many different
  930. people -- because of the way that the FAQ was compiled, I regret
  931. to say that I do not have a complete list of contributors.
  932.  
  933. The aim of this FAQ is to provide information about functional
  934. languages and to reflect widely held views in the functional
  935. programming community.  Any opinions expressed in this message are
  936. those of the individual contributors, and may not be representative
  937. either of my own personal views, or of others in the community.
  938.  
  939. It is very likely that this FAQ contains some significant errors
  940. and omissions: There are no guarantees for the accuracy of the
  941. information provided here.  Of course, your corrections and
  942. contributions are encouraged!
  943.  
  944.  
  945. ---------------------------------------------------------------------------
  946.